#include <gtk/gtk.h>
/* Drag 'n Drop */
-static GtkTargetEntry target_table[] = {
- { "text/uri-list", 0 },
+static const char *target_table[] = {
+ "text/uri-list"
};
typedef struct
static guint color_button_signals[LAST_SIGNAL] = { 0 };
-static const GtkTargetEntry drop_types[] = { { (char *) "application/x-color", 0 } };
+static const char *drop_types[] = { "application/x-color" };
static void gtk_color_button_iface_init (GtkColorChooserInterface *iface);
return (GtkWidget *) g_object_new (GTK_TYPE_COLOR_SWATCH, NULL);
}
-static const GtkTargetEntry dnd_targets[] = {
- { (char *) "application/x-color", 0 }
+static const char *dnd_targets[] = {
+ "application/x-color"
};
void
tmp_list = g_list_last (target_list->list);
while (tmp_list)
{
- GtkTargetPair *pair = tmp_list->data;
- targets = g_list_prepend (targets,
- GINT_TO_POINTER (pair->target));
+ targets = g_list_prepend (targets, tmp_list->data);
tmp_list = tmp_list->prev;
}
tmp_list = info->target_list->list;
while (tmp_list)
{
- GtkTargetPair *pair = tmp_list->data;
-
gtk_selection_add_target (info->ipc_widget,
selection,
- pair->target);
+ tmp_list->data);
tmp_list = tmp_list->next;
}
tmp_list = info->target_list->list;
while (tmp_list)
{
- GtkTargetPair *pair = tmp_list->data;
-
- if (pair->target == target1 || pair->target == target2)
+ if (tmp_list->data == target1 || tmp_list->data == target2)
{
selection_data.selection = NULL;
- selection_data.target = pair->target;
+ selection_data.target = tmp_list->data;
selection_data.data = NULL;
selection_data.length = -1;
{
GList *tmp_target;
GList *tmp_source = NULL;
- GtkWidget *source_widget;
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
g_return_val_if_fail (GDK_IS_DRAG_CONTEXT (context), NULL);
- source_widget = gtk_drag_get_source_widget (context);
if (target_list == NULL)
target_list = gtk_drag_dest_get_target_list (widget);
tmp_target = target_list->list;
while (tmp_target)
{
- GtkTargetPair *pair = tmp_target->data;
tmp_source = gdk_drag_context_list_targets (context);
while (tmp_source)
{
- if (tmp_source->data == GUINT_TO_POINTER (pair->target))
- {
- if ((!(pair->flags & GTK_TARGET_SAME_APP) || source_widget) &&
- (!(pair->flags & GTK_TARGET_SAME_WIDGET) || (source_widget == widget)) &&
- (!(pair->flags & GTK_TARGET_OTHER_APP) || !source_widget) &&
- (!(pair->flags & GTK_TARGET_OTHER_WIDGET) || (source_widget != widget)))
- return pair->target;
- else
- break;
- }
+ if (tmp_source->data == tmp_target->data)
+ return tmp_target->data;
tmp_source = tmp_source->next;
}
tmp_target = tmp_target->next;
return icon_view->priv->reorderable;
}
-static const GtkTargetEntry item_targets[] = {
- { (char *) "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_WIDGET }
+static const char *item_targets[] = {
+ "GTK_TREE_MODEL_ROW"
};
static void set_hand_cursor (GtkWidget *widget,
gboolean show_hand);
-static const GtkTargetEntry link_drop_types[] = {
- { (char *) "text/uri-list", 0 },
- { (char *) "_NETSCAPE_URL", 0 }
+static const char *link_drop_types[] = {
+ "text/uri-list",
+ "_NETSCAPE_URL"
};
static guint link_signals[LAST_SIGNAL] = { 0, };
gulong notify_visible_handler;
};
-static const GtkTargetEntry src_notebook_targets [] = {
- { (char *) "GTK_NOTEBOOK_TAB", GTK_TARGET_SAME_APP },
- { (char *) "application/x-rootwindow-drop", 0 },
+static const char *src_notebook_targets [] = {
+ "GTK_NOTEBOOK_TAB",
+ "application/x-rootwindow-drop"
};
-static const GtkTargetEntry dst_notebook_targets [] = {
- { (char *) "GTK_NOTEBOOK_TAB", GTK_TARGET_SAME_APP },
+static const char *dst_notebook_targets [] = {
+ "GTK_NOTEBOOK_TAB"
};
/*** GtkNotebook Methods ***/
};
/* Target types for dragging from the shortcuts list */
-static const GtkTargetEntry dnd_source_targets[] = {
- { (char *) "DND_GTK_SIDEBAR_ROW", GTK_TARGET_SAME_WIDGET }
+static const char *dnd_source_targets[] = {
+ "DND_GTK_SIDEBAR_ROW"
};
/* Target types for dropping into the shortcuts list */
-static const GtkTargetEntry dnd_drop_targets [] = {
- { (char *) "DND_GTK_SIDEBAR_ROW", GTK_TARGET_SAME_WIDGET }
+static const char *dnd_drop_targets [] = {
+ "DND_GTK_SIDEBAR_ROW"
};
G_DEFINE_TYPE (GtkPlacesSidebar, gtk_places_sidebar, GTK_TYPE_SCROLLED_WINDOW);
*
* Some of the datatypes defined this section are used in
* the #GtkClipboard and drag-and-drop API’s as well. The
- * #GtkTargetEntry and #GtkTargetList objects represent
+ * #GtkTargetList object represents
* lists of data types that are supported when sending or
* receiving data. The #GtkSelectionData object is used to
* store a chunk of data along with the data type and other
/**
* gtk_target_list_new:
* @targets: (array length=ntargets) (allow-none): Pointer to an array
- * of #GtkTargetEntry
+ * of char *
* @ntargets: number of entries in @targets.
*
- * Creates a new #GtkTargetList from an array of #GtkTargetEntry.
+ * Creates a new #GtkTargetList from an array of mime types.
*
* Returns: (transfer full): the new #GtkTargetList.
**/
GtkTargetList *
-gtk_target_list_new (const GtkTargetEntry *targets,
- guint ntargets)
+gtk_target_list_new (const char **targets,
+ guint ntargets)
{
GtkTargetList *result = g_slice_new (GtkTargetList);
result->list = NULL;
g_return_if_fail (list->ref_count > 0);
list->ref_count--;
- if (list->ref_count == 0)
- {
- GList *tmp_list = list->list;
- while (tmp_list)
- {
- GtkTargetPair *pair = tmp_list->data;
- g_slice_free (GtkTargetPair, pair);
+ if (list->ref_count > 0)
+ return;
- tmp_list = tmp_list->next;
- }
-
- g_list_free (list->list);
- g_slice_free (GtkTargetList, list);
- }
+ g_list_free (list->list);
+ g_slice_free (GtkTargetList, list);
}
/**
* gtk_target_list_add:
* @list: a #GtkTargetList
- * @target: the interned atom representing the target
- * @flags: the flags for this target
+ * @target: the mime type of the target
*
* Appends another target to a #GtkTargetList.
**/
void
gtk_target_list_add (GtkTargetList *list,
- GdkAtom target,
- guint flags)
+ const char *target)
{
- GtkTargetPair *pair;
-
g_return_if_fail (list != NULL);
- pair = g_slice_new (GtkTargetPair);
- pair->target = target;
- pair->flags = flags;
-
- list->list = g_list_append (list->list, pair);
+ list->list = g_list_append (list->list, (gpointer) gdk_atom_intern (target, FALSE));
}
static GdkAtom utf8_atom;
/* Keep in sync with gtk_selection_data_targets_include_text()
*/
- gtk_target_list_add (list, utf8_atom, 0);
- gtk_target_list_add (list, ctext_atom, 0);
- gtk_target_list_add (list, text_atom, 0);
- gtk_target_list_add (list, GDK_TARGET_STRING, 0);
- gtk_target_list_add (list, text_plain_utf8_atom, 0);
+ gtk_target_list_add (list, utf8_atom);
+ gtk_target_list_add (list, ctext_atom);
+ gtk_target_list_add (list, text_atom);
+ gtk_target_list_add (list, GDK_TARGET_STRING);
+ gtk_target_list_add (list, text_plain_utf8_atom);
if (!g_get_charset (NULL))
- gtk_target_list_add (list, text_plain_locale_atom, 0);
- gtk_target_list_add (list, text_plain_atom, 0);
+ gtk_target_list_add (list, text_plain_locale_atom);
+ gtk_target_list_add (list, text_plain_atom);
}
/**
atoms = gtk_text_buffer_get_serialize_formats (buffer, &n_atoms);
for (i = 0; i < n_atoms; i++)
- gtk_target_list_add (list, atoms[i], 0);
+ gtk_target_list_add (list, atoms[i]);
g_free (atoms);
}
{
GSList *formats, *f;
gchar **mimes, **m;
- GdkAtom atom;
g_return_if_fail (list != NULL);
mimes = gdk_pixbuf_format_get_mime_types (fmt);
for (m = mimes; *m; m++)
{
- atom = gdk_atom_intern (*m, FALSE);
- gtk_target_list_add (list, atom, 0);
+ gtk_target_list_add (list, *m);
}
g_strfreev (mimes);
}
init_atoms ();
- gtk_target_list_add (list, text_uri_list_atom, 0);
+ gtk_target_list_add (list, text_uri_list_atom);
}
/**
for (l = source->list; l; l = l->next)
{
- target->list = g_list_prepend (target->list, g_slice_dup (GtkTargetPair, l->data));
+ target->list = g_list_prepend (target->list, l->data);
}
}
* Prepends a table of #GtkTargetEntry to a target list.
**/
void
-gtk_target_list_add_table (GtkTargetList *list,
- const GtkTargetEntry *targets,
- guint ntargets)
+gtk_target_list_add_table (GtkTargetList *list,
+ const char **targets,
+ guint ntargets)
{
gint i;
for (i=ntargets-1; i >= 0; i--)
{
- GtkTargetPair *pair = g_slice_new (GtkTargetPair);
- pair->target = gdk_atom_intern (targets[i].target, FALSE);
- pair->flags = targets[i].flags;
-
- list->list = g_list_prepend (list->list, pair);
+ list->list = g_list_prepend (list->list, (gpointer) gdk_atom_intern (targets[i], FALSE));
}
}
**/
void
gtk_target_list_remove (GtkTargetList *list,
- GdkAtom target)
+ GdkAtom target)
{
- GList *tmp_list;
-
g_return_if_fail (list != NULL);
- tmp_list = list->list;
- while (tmp_list)
- {
- GtkTargetPair *pair = tmp_list->data;
-
- if (pair->target == target)
- {
- g_slice_free (GtkTargetPair, pair);
-
- list->list = g_list_remove_link (list->list, tmp_list);
- g_list_free_1 (tmp_list);
-
- return;
- }
-
- tmp_list = tmp_list->next;
- }
+ list->list = g_list_remove (list->list, (gpointer) target);
}
/**
* gtk_target_list_find:
* @list: a #GtkTargetList
- * @target: an interned atom representing the target to search for
+ * @target: a string representing the target to search for
*
* Looks up a given target in a #GtkTargetList.
*
**/
gboolean
gtk_target_list_find (GtkTargetList *list,
- GdkAtom target)
+ const char *target)
{
- GList *tmp_list;
-
g_return_val_if_fail (list != NULL, FALSE);
+ g_return_val_if_fail (target != NULL, FALSE);
- tmp_list = list->list;
- while (tmp_list)
- {
- GtkTargetPair *pair = tmp_list->data;
-
- if (pair->target == target)
- return TRUE;
-
- tmp_list = tmp_list->next;
- }
-
- return FALSE;
+ return g_list_find (list->list, (gpointer) gdk_atom_intern (target, FALSE)) != NULL;
}
GdkAtom *
i = 0;
for (l = list->list; l; l = l->next)
- atoms[i++] = ((GtkTargetPair *) l->data)->target;
+ atoms[i++] = l->data;
if (n_atoms)
*n_atoms = n;
g_return_if_fail (selection != NULL);
list = gtk_selection_target_list_get (widget, selection);
- gtk_target_list_add (list, target, 0);
+ gtk_target_list_add (list, target);
gdk_selection_add_targets (gtk_widget_get_window (widget), selection, &target, 1);
}
{
for (l = list->list; l; l = l->next)
{
- GtkTargetPair *pair = (GtkTargetPair *)l->data;
- if (pair->target == targets[i])
+ if ((GdkAtom) l->data == targets[i])
{
result = TRUE;
break;
guint count;
GList *tmp_list;
GtkTargetList *target_list;
- GtkTargetPair *pair;
target_list = gtk_selection_target_list_get (widget,
data->selection);
tmp_list = target_list->list;
while (tmp_list)
{
- pair = (GtkTargetPair *)tmp_list->data;
- *p++ = pair->target;
+ *p++ = (GdkAtom) tmp_list->data;
tmp_list = tmp_list->next;
}
G_BEGIN_DECLS
-typedef struct _GtkTargetPair GtkTargetPair;
-
-/**
- * GtkTargetPair:
- * @target: #GdkAtom representation of the target type
- * @flags: #GtkTargetFlags for DND
- * @info: an application-assigned integer ID which will
- * get passed as a parameter to e.g the #GtkWidget::selection-get
- * signal. It allows the application to identify the target
- * type without extensive string compares.
- *
- * A #GtkTargetPair is used to represent the same
- * information as a table of #GtkTargetEntry, but in
- * an efficient form.
- */
-struct _GtkTargetPair
-{
- GdkAtom target;
- guint flags;
-};
-
/**
* GtkTargetList:
*
* opaque.
*/
typedef struct _GtkTargetList GtkTargetList;
-typedef struct _GtkTargetEntry GtkTargetEntry;
#define GTK_TYPE_SELECTION_DATA (gtk_selection_data_get_type ())
#define GTK_TYPE_TARGET_LIST (gtk_target_list_get_type ())
-/**
- * GtkTargetFlags:
- * @GTK_TARGET_SAME_APP: If this is set, the target will only be selected
- * for drags within a single application.
- * @GTK_TARGET_SAME_WIDGET: If this is set, the target will only be selected
- * for drags within a single widget.
- * @GTK_TARGET_OTHER_APP: If this is set, the target will not be selected
- * for drags within a single application.
- * @GTK_TARGET_OTHER_WIDGET: If this is set, the target will not be selected
- * for drags withing a single widget.
- *
- * The #GtkTargetFlags enumeration is used to specify
- * constraints on a #GtkTargetEntry.
- */
-typedef enum {
- GTK_TARGET_SAME_APP = 1 << 0, /*< nick=same-app >*/
- GTK_TARGET_SAME_WIDGET = 1 << 1, /*< nick=same-widget >*/
- GTK_TARGET_OTHER_APP = 1 << 2, /*< nick=other-app >*/
- GTK_TARGET_OTHER_WIDGET = 1 << 3 /*< nick=other-widget >*/
-} GtkTargetFlags;
-
-/**
- * GtkTargetEntry:
- * @target: a string representation of the target type
- * @flags: #GtkTargetFlags for DND
- * @info: an application-assigned integer ID which will
- * get passed as a parameter to e.g the #GtkWidget::selection-get
- * signal. It allows the application to identify the target
- * type without extensive string compares.
- *
- * A #GtkTargetEntry represents a single type of
- * data than can be supplied for by a widget for a selection
- * or for supplied or received during drag-and-drop.
- */
-struct _GtkTargetEntry
-{
- gchar *target;
- guint flags;
-};
-
GDK_AVAILABLE_IN_ALL
GType gtk_target_list_get_type (void) G_GNUC_CONST;
GDK_AVAILABLE_IN_ALL
-GtkTargetList *gtk_target_list_new (const GtkTargetEntry *targets,
+GtkTargetList *gtk_target_list_new (const char **targets,
guint ntargets);
GDK_AVAILABLE_IN_ALL
GtkTargetList *gtk_target_list_ref (GtkTargetList *list);
const GtkTargetList *source);
GDK_AVAILABLE_IN_ALL
void gtk_target_list_add (GtkTargetList *list,
- GdkAtom target,
- guint flags);
+ const char *target);
GDK_AVAILABLE_IN_ALL
void gtk_target_list_add_text_targets (GtkTargetList *list);
GDK_AVAILABLE_IN_ALL
void gtk_target_list_add_uri_targets (GtkTargetList *list);
GDK_AVAILABLE_IN_ALL
void gtk_target_list_add_table (GtkTargetList *list,
- const GtkTargetEntry *targets,
+ const char **targets,
guint ntargets);
GDK_AVAILABLE_IN_ALL
void gtk_target_list_remove (GtkTargetList *list,
- GdkAtom target);
+ const char *target);
GDK_AVAILABLE_IN_ALL
gboolean gtk_target_list_find (GtkTargetList *list,
- GdkAtom target);
+ const char *target);
GDK_AVAILABLE_IN_ALL
gboolean gtk_selection_owner_set (GtkWidget *widget,
if (include_local)
gtk_target_list_add (target_list,
- gdk_atom_intern_static_string ("GTK_TEXT_BUFFER_CONTENTS"),
- GTK_TARGET_SAME_APP);
+ gdk_atom_intern_static_string ("GTK_TEXT_BUFFER_CONTENTS"));
gtk_target_list_add_rich_text_targets (target_list,
deserializable,
static GdkAtom dnd_target_atom_item = NULL;
static GdkAtom dnd_target_atom_group = NULL;
-static const GtkTargetEntry dnd_targets[] =
+static const char *dnd_targets[] =
{
- { (char *) "application/x-gtk-tool-palette-item", GTK_TARGET_SAME_APP },
- { (char *) "application/x-gtk-tool-palette-group", GTK_TARGET_SAME_APP },
+ "application/x-gtk-tool-palette-item",
+ "application/x-gtk-tool-palette-group"
};
static void gtk_tool_palette_set_hadjustment (GtkToolPalette *palette,
if (dnd_target_atom_item == NULL)
{
- dnd_target_atom_item = gdk_atom_intern_static_string (dnd_targets[0].target);
- dnd_target_atom_group = gdk_atom_intern_static_string (dnd_targets[1].target);
+ dnd_target_atom_item = gdk_atom_intern_static_string (dnd_targets[0]);
+ dnd_target_atom_group = gdk_atom_intern_static_string (dnd_targets[1]);
}
gtk_widget_set_has_window (GTK_WIDGET (palette), FALSE);
GtkToolPaletteDragTargets targets,
GdkDragAction actions)
{
- GtkTargetEntry entries[G_N_ELEMENTS (dnd_targets)];
+ const char *entries[G_N_ELEMENTS (dnd_targets)];
gint n_entries = 0;
GtkTargetList *list;
/**
* gtk_tool_palette_get_drag_target_item:
*
- * Gets the target entry for a dragged #GtkToolItem.
+ * Gets the mime type for a dragged #GtkToolItem.
*
* Returns: (transfer none): the #GtkTargetEntry for a dragged item.
*
* Since: 2.20
*/
-const GtkTargetEntry*
+const char *
gtk_tool_palette_get_drag_target_item (void)
{
- return &dnd_targets[0];
+ return dnd_targets[0];
}
/**
*
* Since: 2.20
*/
-const GtkTargetEntry*
+const char *
gtk_tool_palette_get_drag_target_group (void)
{
- return &dnd_targets[1];
+ return dnd_targets[1];
}
void
GdkDragAction actions);
GDK_AVAILABLE_IN_ALL
-const GtkTargetEntry* gtk_tool_palette_get_drag_target_item (void) G_GNUC_CONST;
+const char * gtk_tool_palette_get_drag_target_item (void) G_GNUC_CONST;
GDK_AVAILABLE_IN_ALL
-const GtkTargetEntry* gtk_tool_palette_get_drag_target_group (void) G_GNUC_CONST;
+const char * gtk_tool_palette_get_drag_target_group (void) G_GNUC_CONST;
G_END_DECLS
if (reorderable)
{
- const GtkTargetEntry row_targets[] = {
- { (char *) "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_WIDGET }
+ const char *row_targets[] = {
+ "GTK_TREE_MODEL_ROW"
};
GtkTargetList *targets;
GList *foci;
};
-static const GtkTargetEntry dnd_dest_targets [] = {
- { (char *) "application/x-rootwindow-drop", 0 },
+static const char *dnd_dest_targets [] = {
+ "application/x-rootwindow-drop"
};
enum {
gboolean have_drag;
-static GtkTargetEntry target_table[] = {
- { "STRING", 0 },
- { "text/plain", 0 },
- { "application/x-rootwindow-drop", 0 }
+static const char *target_table[] = {
+ "STRING",
+ "text/plain",
+ "application/x-rootwindow-drop"
};
static guint n_targets = sizeof(target_table) / sizeof(target_table[0]);
return TRUE;
}
-static const GtkTargetEntry item_targets[] = {
- { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_APP }
+static const char *item_targets[] = {
+ "GTK_TREE_MODEL_ROW"
};
gint
#include <gtk/gtk.h>
-static GtkTargetEntry row_targets[] =
+static const char *row_targets[] =
{
- { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_APP }
+ "GTK_TREE_MODEL_ROW"
};
static void
#include <gtk/gtk.h>
-static GtkTargetEntry entries[] = {
- { "GTK_LIST_BOX_ROW", GTK_TARGET_SAME_APP }
+static const char *entries[] = {
+ "GTK_LIST_BOX_ROW"
};
static void
NULL
};
-static const GtkTargetEntry button_targets[] = {
- { "GTK_NOTEBOOK_TAB", GTK_TARGET_SAME_APP },
+static const char *button_targets[] = {
+ "GTK_NOTEBOOK_TAB"
};
static GtkNotebook*
GtkWidget *hbox;
GtkWidget *scrolled;
- static GtkTargetEntry targetlist[] = {
- { "STRING", 0 },
- { "TEXT", 0 },
- { "COMPOUND_TEXT", 0 }
+ static const char *targetlist[] = {
+ "STRING",
+ "TEXT",
+ "COMPOUND_TEXT"
};
static gint ntargets = sizeof(targetlist) / sizeof(targetlist[0]);
GtkTargetList *list;
return TRUE;
}
-static GtkTargetEntry target_table[] = {
- { "application/x-toolbar-item", 0 }
+static const char *target_table[] = {
+ "application/x-toolbar-item"
};
static void
gtk_widget_set_sensitive (button, FALSE);
}
-static GtkTargetEntry row_targets[] = {
- { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_APP }
+static const char *row_targets[] = {
+ "GTK_TREE_MODEL_ROW"
};
int
return GTK_TREE_MODEL (model);
}
-static GtkTargetEntry entries[] = {
- { "text/plain", 0 }
+static const char *entries[] = {
+ "text/plain"
};
static GtkWidget *
g_print ("Row activated\n");
}
-static GtkTargetEntry row_targets[] = {
- { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_APP }
+static const char *row_targets[] = {
+ "GTK_TREE_MODEL_ROW"
};
int
test_with_data (void)
{
GtkClipboard *clipboard = gtk_clipboard_get_for_display (gdk_display_get_default (), GDK_SELECTION_CLIPBOARD);
- GtkTargetEntry entries[] = { { .target = TARGET_TEXT } };
+ const char *entries[] = { TARGET_TEXT };
GtkTargetList *targets;
targets = gtk_target_list_new (entries, G_N_ELEMENTS(entries));
projects / gtk4.git / commitdiff